home *** CD-ROM | disk | FTP | other *** search
/ Macwelt 1 / Macwelt DVD 1.toast / Software für Mac-OS X / Entwickler-Tools / netbeans / modules / ext / djava.jar / koala / dynamicjava / classinfo / TreeClassInfo.class (.txt) < prev    next >
Encoding:
Java Class File  |  2000-03-14  |  8.0 KB  |  341 lines
  1. package koala.dynamicjava.classinfo;
  2.  
  3. import java.lang.reflect.Modifier;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.LinkedList;
  7. import java.util.List;
  8. import java.util.Map;
  9. import java.util.Set;
  10. import koala.dynamicjava.tree.ClassDeclaration;
  11. import koala.dynamicjava.tree.FieldDeclaration;
  12. import koala.dynamicjava.tree.InterfaceDeclaration;
  13. import koala.dynamicjava.tree.MethodDeclaration;
  14. import koala.dynamicjava.tree.TypeDeclaration;
  15.  
  16. public class TreeClassInfo implements ClassInfo {
  17.    private static final String DECLARING_CLASS = "declaringClass";
  18.    public static final String ANONYMOUS_DECLARING_CLASS = "anonymousDeclaringClass";
  19.    private static final String TREE_VISITED = "treeVisited";
  20.    private TypeDeclaration classTree;
  21.    private ClassFinder classFinder;
  22.    private int dimension;
  23.    private String name;
  24.    private ClassInfo superclass;
  25.    private boolean interfaceInfo;
  26.    private ClassInfo[] interfaces;
  27.    private Map fields = new HashMap();
  28.    private Map methods = new HashMap();
  29.    private List constructors = new LinkedList();
  30.    private List classes = new LinkedList();
  31.    private boolean compilable = true;
  32.    private int methodCount;
  33.  
  34.    public Class getJavaClass() {
  35.       throw new IllegalStateException();
  36.    }
  37.  
  38.    public TypeDeclaration getTypeDeclaration() {
  39.       return this.classTree;
  40.    }
  41.  
  42.    public ClassFinder getClassFinder() {
  43.       return this.classFinder;
  44.    }
  45.  
  46.    public boolean isCompilable() {
  47.       return this.compilable;
  48.    }
  49.  
  50.    public void setCompilable(boolean var1) {
  51.       this.compilable = var1;
  52.    }
  53.  
  54.    public ClassInfo getDeclaringClass() {
  55.       return this.dimension == 0 ? (ClassInfo)this.classTree.getProperty("declaringClass") : null;
  56.    }
  57.  
  58.    public ClassInfo getAnonymousDeclaringClass() {
  59.       return this.dimension == 0 ? (ClassInfo)this.classTree.getProperty("anonymousDeclaringClass") : null;
  60.    }
  61.  
  62.    public int getModifiers() {
  63.       return this.dimension == 0 ? this.classTree.getAccessFlags() : 1;
  64.    }
  65.  
  66.    public String getName() {
  67.       return this.name;
  68.    }
  69.  
  70.    public ClassInfo getSuperclass() {
  71.       if (this.superclass == null) {
  72.          if (this.interfaceInfo) {
  73.             this.superclass = this.lookupClass("java.lang.Object");
  74.          } else {
  75.             ClassDeclaration var1 = (ClassDeclaration)this.classTree;
  76.             this.superclass = this.lookupClass(var1.getSuperclass(), this.getDeclaringClass());
  77.          }
  78.       }
  79.  
  80.       return this.superclass;
  81.    }
  82.  
  83.    public ClassInfo[] getInterfaces() {
  84.       if (this.interfaces == null) {
  85.          if (this.dimension > 0) {
  86.             this.interfaces = new ClassInfo[]{this.lookupClass("java.lang.Cloneable"), this.lookupClass("java.io.Serializable")};
  87.          } else {
  88.             List var1 = this.classTree.getInterfaces();
  89.             if (var1 != null) {
  90.                this.interfaces = new ClassInfo[var1.size()];
  91.                Iterator var2 = var1.iterator();
  92.  
  93.                String var4;
  94.                for(int var3 = 0; var2.hasNext(); this.interfaces[var3++] = this.lookupClass(var4, this.getDeclaringClass())) {
  95.                   var4 = (String)var2.next();
  96.                }
  97.             } else {
  98.                this.interfaces = new ClassInfo[0];
  99.             }
  100.          }
  101.       }
  102.  
  103.       return (ClassInfo[])this.interfaces.clone();
  104.    }
  105.  
  106.    public FieldInfo getField(FieldDeclaration var1) {
  107.       return (TreeFieldInfo)this.fields.get(var1.getName());
  108.    }
  109.  
  110.    public FieldInfo[] getFields() {
  111.       if (this.dimension != 0) {
  112.          return new FieldInfo[0];
  113.       } else {
  114.          Set var1 = this.fields.keySet();
  115.          Iterator var2 = var1.iterator();
  116.          FieldInfo[] var3 = new FieldInfo[var1.size()];
  117.  
  118.          for(int var4 = 0; var2.hasNext(); var3[var4++] = (FieldInfo)this.fields.get(var2.next())) {
  119.          }
  120.  
  121.          return var3;
  122.       }
  123.    }
  124.  
  125.    public ConstructorInfo[] getConstructors() {
  126.       if (this.dimension != 0) {
  127.          return new ConstructorInfo[0];
  128.       } else {
  129.          Iterator var1 = this.constructors.iterator();
  130.          ConstructorInfo[] var2 = new ConstructorInfo[this.constructors.size()];
  131.  
  132.          for(int var3 = 0; var1.hasNext(); var2[var3++] = (ConstructorInfo)var1.next()) {
  133.          }
  134.  
  135.          return var2;
  136.       }
  137.    }
  138.  
  139.    public MethodInfo getMethod(MethodDeclaration var1) {
  140.       Set var2 = this.methods.keySet();
  141.       Iterator var3 = var2.iterator();
  142.  
  143.       while(var3.hasNext()) {
  144.          for(TreeMethodInfo var6 : (List)this.methods.get(var3.next())) {
  145.             if (var6.getMethodDeclaration() == var1) {
  146.                return var6;
  147.             }
  148.          }
  149.       }
  150.  
  151.       throw new IllegalArgumentException();
  152.    }
  153.  
  154.    public MethodInfo[] getMethods() {
  155.       if (this.dimension != 0) {
  156.          return new MethodInfo[0];
  157.       } else {
  158.          MethodInfo[] var1 = new MethodInfo[this.methodCount];
  159.          Iterator var2 = this.methods.values().iterator();
  160.          int var3 = 0;
  161.  
  162.          while(var2.hasNext()) {
  163.             for(Iterator var4 = ((List)var2.next()).iterator(); var4.hasNext(); var1[var3++] = (MethodInfo)var4.next()) {
  164.             }
  165.          }
  166.  
  167.          return var1;
  168.       }
  169.    }
  170.  
  171.    public ClassInfo[] getDeclaredClasses() {
  172.       if (this.dimension != 0) {
  173.          return new ClassInfo[0];
  174.       } else {
  175.          Iterator var1 = this.classes.iterator();
  176.          ClassInfo[] var2 = new ClassInfo[this.classes.size()];
  177.  
  178.          for(int var3 = 0; var1.hasNext(); var2[var3++] = (ClassInfo)var1.next()) {
  179.          }
  180.  
  181.          return var2;
  182.       }
  183.    }
  184.  
  185.    public ClassInfo getArrayType() {
  186.       return new TreeClassInfo(this);
  187.    }
  188.  
  189.    public boolean isInterface() {
  190.       return this.classTree instanceof InterfaceDeclaration;
  191.    }
  192.  
  193.    public boolean isArray() {
  194.       return this.dimension > 0;
  195.    }
  196.  
  197.    public boolean isPrimitive() {
  198.       return false;
  199.    }
  200.  
  201.    public ClassInfo getComponentType() {
  202.       if (!this.isArray()) {
  203.          throw new IllegalStateException();
  204.       } else {
  205.          TreeClassInfo var1 = new TreeClassInfo(this.classTree, this.classFinder);
  206.  
  207.          for(int var2 = 0; var2 < this.dimension - 1; ++var2) {
  208.             var1 = new TreeClassInfo(var1);
  209.          }
  210.  
  211.          return var1;
  212.       }
  213.    }
  214.  
  215.    public boolean equals(Object var1) {
  216.       return var1 != null && var1 instanceof ClassInfo ? this.getName().equals(((ClassInfo)var1).getName()) : false;
  217.    }
  218.  
  219.    private String fullName() {
  220.       ClassInfo var2 = (ClassInfo)this.classTree.getProperty("declaringClass");
  221.       String var1;
  222.       if (var2 != null) {
  223.          var1 = var2.getName() + "$";
  224.       } else {
  225.          var1 = this.classFinder.getCurrentPackage();
  226.          if (!var1.equals("")) {
  227.             var1 = var1 + ".";
  228.          }
  229.       }
  230.  
  231.       return var1 + this.classTree.getName();
  232.    }
  233.  
  234.    private ClassInfo lookupClass(String var1) {
  235.       try {
  236.          return this.classFinder.lookupClass(var1);
  237.       } catch (ClassNotFoundException var3) {
  238.          throw new NoClassDefFoundError(var3.getMessage());
  239.       }
  240.    }
  241.  
  242.    private ClassInfo lookupClass(String var1, ClassInfo var2) {
  243.       try {
  244.          return var2 != null ? this.classFinder.lookupClass(var1, var2) : this.classFinder.lookupClass(var1);
  245.       } catch (ClassNotFoundException var4) {
  246.          throw new NoClassDefFoundError(var4.getMessage());
  247.       }
  248.    }
  249.  
  250.    private int getNestingLevel() {
  251.       int var1 = -1;
  252.  
  253.       for(Object var2 = this; !Modifier.isStatic(((ClassInfo)var2).getModifiers()) && (var2 = ((ClassInfo)var2).getDeclaringClass()) != null; ++var1) {
  254.       }
  255.  
  256.       return var1;
  257.    }
  258.  
  259.    // $FF: synthetic method
  260.    static TypeDeclaration access$0(TreeClassInfo var0) {
  261.       return var0.classTree;
  262.    }
  263.  
  264.    // $FF: synthetic method
  265.    static String access$1() {
  266.       return TREE_VISITED;
  267.    }
  268.  
  269.    // $FF: synthetic method
  270.    static int access$2(TreeClassInfo var0) {
  271.       return var0.getNestingLevel();
  272.    }
  273.  
  274.    // $FF: synthetic method
  275.    static List access$3(TreeClassInfo var0) {
  276.       return var0.constructors;
  277.    }
  278.  
  279.    // $FF: synthetic method
  280.    static String access$4() {
  281.       return DECLARING_CLASS;
  282.    }
  283.  
  284.    // $FF: synthetic method
  285.    static ClassFinder access$5(TreeClassInfo var0) {
  286.       return var0.classFinder;
  287.    }
  288.  
  289.    // $FF: synthetic method
  290.    static List access$6(TreeClassInfo var0) {
  291.       return var0.classes;
  292.    }
  293.  
  294.    // $FF: synthetic method
  295.    static Map access$7(TreeClassInfo var0) {
  296.       return var0.fields;
  297.    }
  298.  
  299.    // $FF: synthetic method
  300.    static Map access$8(TreeClassInfo var0) {
  301.       return var0.methods;
  302.    }
  303.  
  304.    // $FF: synthetic method
  305.    static int access$9(TreeClassInfo var0) {
  306.       return var0.methodCount;
  307.    }
  308.  
  309.    // $FF: synthetic method
  310.    static void access$10(TreeClassInfo var0, int var1) {
  311.       var0.methodCount = var1;
  312.    }
  313.  
  314.    public TreeClassInfo(TypeDeclaration var1, ClassFinder var2) {
  315.       this.classFinder = var2;
  316.       this.classTree = var1;
  317.       this.name = this.fullName();
  318.       this.interfaceInfo = var1 instanceof InterfaceDeclaration;
  319.       MembersVisitor var10000 = new MembersVisitor;
  320.       if (this == null) {
  321.          throw null;
  322.       } else {
  323.          var10000.<init>(this);
  324.          this.classTree.setProperty("treeVisited", (Object)null);
  325.       }
  326.    }
  327.  
  328.    public TreeClassInfo(TreeClassInfo var1) {
  329.       this.classFinder = var1.classFinder;
  330.       this.classTree = var1.classTree;
  331.       this.dimension = var1.dimension + 1;
  332.       this.name = "[" + (var1.isArray() ? var1.getName() : "L" + var1.getName() + ";");
  333.       MembersVisitor var10000 = new MembersVisitor;
  334.       if (this == null) {
  335.          throw null;
  336.       } else {
  337.          var10000.<init>(this);
  338.       }
  339.    }
  340. }
  341.